home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / xcoral / xcoral.lha / xcoral-1.72 / new_window.c < prev    next >
C/C++ Source or Header  |  1993-02-21  |  11KB  |  492 lines
  1. /*
  2. ** Copyright 1989, 1992 by Lionel Fournigault
  3. **
  4. ** Permission to use, copy, and distribute for non-commercial purposes,
  5. ** is hereby granted without fee, providing that the above copyright
  6. ** notice appear in all copies and that both the copyright notice and this
  7. ** permission notice appear in supporting documentation.
  8. ** The software may be modified for your own purposes, but modified versions
  9. ** may not be distributed.
  10. ** This software is provided "as is" without any expressed or implied warranty.
  11. **
  12. **
  13. */
  14.  
  15. #include <stdio.h>
  16. #include <X11/Xlib.h>
  17. #include <X11/Xutil.h>
  18. #include <string.h>
  19.  
  20. #include "options.h"
  21. #include "xcoral.h"
  22. #include "browser.h"
  23. #include "logo.bm"
  24. #include "flist.h"
  25.  
  26. extern Trans st_initial;
  27.  
  28. static void SetProp ();
  29. static int add_window ();
  30.  
  31. /*
  32. **    Function name : CreateWindow
  33. **
  34. **    Description : Fabrication d'une fenetre d'edition.
  35. **    Input : 
  36. **    Ouput : La structure associee.
  37. */
  38. EdWin *CreateWindow ()
  39. {
  40.     EdWin        *edtmp;
  41.     Window        root;
  42.     int         screen;
  43.     char         *malloc ();
  44.     XYMenu         *MakeMenus (); 
  45.     Text        *MakeTextWindow ();
  46.     MWin        *MakeControlPanel ();
  47.     static         Atom wm_delete_window;
  48.  
  49.     screen = DefaultScreen ( dpy );
  50.     root = RootWindow ( dpy, screen );
  51.     
  52.     edtmp = ( EdWin * ) malloc ( sizeof ( EdWin ));
  53.  
  54.     if ( add_window ( edtmp ) < 0 ) {
  55.               if ( edtmp != 0 )
  56.             (void) free ( (char *) edtmp );
  57.         return 0;
  58.     }
  59.     
  60.     edtmp -> w_frame = XCreateSimpleWindow (dpy, root,
  61.         GetOpGeo ( OP_X ), GetOpGeo ( OP_Y ),
  62.         GetOpGeo ( OP_WIDTH ), GetOpGeo( OP_HEIGHT ), GetOpBW (),
  63.         GetOpBD (), GetOpColor ( OP_MENU_BG ));
  64.  
  65.     (void) SetProp ( edtmp -> w_frame ); 
  66.  
  67.     XSelectInput ( dpy, edtmp->w_frame , ExposureMask |
  68.         ButtonPressMask | ButtonReleaseMask | EnterWindowMask
  69.         | LeaveWindowMask | KeyPressMask | StructureNotifyMask );
  70.  
  71.     edtmp -> menu = MakeMenus ( dpy, edtmp->w_frame, 
  72.         menu_names, item_names, func_names );
  73.  
  74.     edtmp -> mwin = MakeControlPanel ( edtmp->w_frame );
  75.  
  76.     edtmp -> scroll = MakeScroll ( dpy, edtmp->w_frame,
  77.         GetOpGeo ( OP_WIDTH ) - GetScrollWidth () - W_SPACE,
  78.         HeightMenuBar ( edtmp -> menu -> font ) + 1 + W_SPACE );
  79.  
  80.     SetScrollFont ( edtmp -> scroll, GetOpFont ( OP_TEXT_FONT) );
  81.  
  82.     edtmp -> text = MakeTextWindow ( dpy, edtmp -> w_frame, 
  83.             W_SPACE, HeightMenuBar ( edtmp -> menu -> font ) + 1 + W_SPACE );
  84.  
  85.     edtmp -> buf = GetBuffer ( (unsigned) SIZEOF_BUFFER );
  86.  
  87.     edtmp -> text -> buf = edtmp -> buf;
  88.     edtmp -> text -> swin = edtmp -> scroll;
  89.     edtmp -> text -> mwin = edtmp -> mwin;
  90.     edtmp -> scroll -> text = ( char * ) edtmp -> text;
  91.  
  92.     SetHiddenWindow ( edtmp -> menu, edtmp -> text -> window, edtmp -> text -> Cgc );
  93.  
  94.     if ( XSaveContext ( dpy, edtmp->w_frame, EdContext, (caddr_t) edtmp ) != 0 )
  95.         ( void ) printf ("create_env XSaveContext Error\n" );
  96.  
  97.     edtmp -> stat = (ST *) &st_initial;
  98.     edtmp -> width = edtmp -> height = 0;
  99.     (void) strcpy ( edtmp -> text -> filename, "NoName" ); 
  100.  
  101.     wm_delete_window = XInternAtom( dpy, "WM_DELETE_WINDOW", False);
  102.     (void) XSetWMProtocols ( dpy, edtmp -> w_frame, &wm_delete_window, 1);
  103.  
  104.     return edtmp;
  105. }
  106.  
  107. /*
  108. **    Function name : ConfigWindow
  109. **
  110. **    Description : Positionne la geometrie des fenetres.
  111. **    Input : Le contexte d'edition, largeur er hauteur.
  112. **    Ouput :
  113. */
  114. ConfigWindow ( e, width, height )
  115.     EdWin   *e;
  116.     register width, height;
  117. {
  118.        register int hbar, hmess, wscroll, i, x;
  119.  
  120.        e -> width = width;
  121.        e -> height = height;
  122.        hbar = HeightMenuBar ( e -> menu -> font );
  123.        hmess = HeightOfMess ();
  124.        wscroll = GetScrollWidth ();
  125.  
  126. #ifdef DEBUG
  127.        fprintf ( stderr, "ConfigWindow width = %d, height = %d\n",
  128.         width, height );
  129.        fprintf ( stderr, "ConfigWindow hbar = %d, hmess = %d, wscroll = %d\n",
  130.         hbar, hmess, wscroll );
  131. #endif
  132.  
  133.        x = height - ( hbar + hmess + 2 ) - ( 2 * W_SPACE );
  134.        x -= ( 2 * MARGE );
  135.     i = x / e -> text -> font_height;
  136.  
  137.        SetScrollLinePage ( e -> scroll, i );
  138.        SetMenuBarWidth ( e -> menu, width );
  139.        ShowControlPanel ( e -> mwin, width, height );
  140.        ShowWindowText ( dpy, e -> text, width - wscroll - 1 - ( 2 * W_SPACE ) ,
  141.                height - hbar - hmess - 2 - ( 2 * W_SPACE) );
  142.  
  143.            if ( DoesSaveUnders ( DefaultScreenOfDisplay ( dpy ) ) != True )
  144.         SetMenuPixmap ( dpy, e -> menu, width - wscroll - 1 );
  145.  
  146.        i = e -> text -> no_current_line - e -> text -> n1 - 1;
  147. #ifdef DEBUG
  148.        fprintf ( stderr, "no_current = %d n1 = %d\n", 
  149.         e -> text -> no_current_line, e -> text -> n1 );
  150. #endif
  151.        RefreshScroll ( dpy, e -> scroll, width - W_SPACE,
  152.         height - hbar - hmess - 2 - ( 2 * W_SPACE) , i );
  153. }
  154.  
  155.  
  156. /*
  157. **    Function name : SetProp
  158. **
  159. **    Description : Initialisation des proprietes pour une fenetre
  160. **        d'edition.
  161. **    Input : La fenetre
  162. **    Ouput :
  163. */
  164. static void SetProp ( w )
  165.     Window     w;
  166. {
  167.     XSizeHints sizehints;
  168.     XWMHints wm_hints;
  169.     
  170.     wm_hints.icon_pixmap = XCreatePixmapFromBitmapData ( dpy, w, icon_bits,
  171.             icon_width, icon_height,
  172.             WhitePixel ( dpy, DefaultScreen ( dpy )),
  173.             BlackPixel ( dpy, DefaultScreen ( dpy )),
  174.             DefaultDepth ( dpy, DefaultScreen ( dpy )));
  175.     
  176. /*    sizehints.flags = PMinSize | PMaxSize | PPosition | PSize | USPosition;  */
  177.  
  178.     sizehints.flags = PMinSize | PMaxSize;
  179.  
  180.     sizehints.height = GetOpGeo ( OP_HEIGHT );
  181.     sizehints.width = GetOpGeo ( OP_WIDTH );
  182.     sizehints.x = GetOpGeo ( OP_X );
  183.     sizehints.y = GetOpGeo ( OP_Y );
  184.  
  185.     if ( sizehints.x != 0 ||sizehints.y != 0 ) 
  186.         sizehints.flags |=  USPosition;
  187. #ifdef DEBUG
  188.     (void) fprintf ( stderr, "x = %d    y = %d\n", sizehints.x, sizehints.y );
  189. #endif
  190.     sizehints.min_width = (DisplayWidth ( dpy,DefaultScreen ( dpy )) *2 ) / 5; 
  191.     sizehints.min_height = (DisplayHeight ( dpy,DefaultScreen ( dpy )) * 2 ) / 5; 
  192.     sizehints.max_width = (DisplayWidth (dpy,DefaultScreen (dpy)) * 5 ) / 6;
  193.     sizehints.max_height = (DisplayHeight (dpy,DefaultScreen (dpy)) * 5 ) / 6; 
  194.  
  195.     wm_hints.flags = InputHint | StateHint | IconPixmapHint;
  196.     wm_hints.input = True;
  197.     wm_hints.initial_state = NormalState;
  198.  
  199.     XSetWMProperties ( dpy, w, 0, 0, 0, 0, &sizehints, &wm_hints, 0 );
  200. }
  201.  
  202.  
  203. /*
  204. **    Function name : add_window
  205. **
  206. **    Description : Ajoute une fenetre d'edition dans
  207. **        la table principale.
  208. **    Input : Le contexte d'edition.
  209. **    Ouput : 0 si OK -1 sinon.
  210. */
  211. static int add_window ( e )
  212.     EdWin    *e;
  213. {
  214.     register EdWin    **t;
  215.  
  216.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  217.         if ( *t == 0 ) {
  218.              *t  = e;
  219.              break;
  220.         }
  221.     }
  222.     if ( t == TWin + MAXWIN )
  223.         return (- 1);
  224.     else
  225.         return 0;
  226. }
  227.  
  228.  
  229. /*
  230. **    Function name : DisplayOpenFiles
  231. **
  232. **    Description : Affiche la liste des fichiers ouverts.
  233. **    Input : Le text courant.
  234. **    Ouput :
  235. */
  236. void DisplayOpenFiles ( text )
  237.     Text *text;
  238. {
  239.     register EdWin    **t;
  240.     register char *str, *tmp;
  241.     register int n;
  242.  
  243.        if ( GetVisibility ( dpy, text ) == False )
  244.         return;
  245.  
  246.     tmp = (char *) GetStringFromSelect ( text -> window, OPENFILES );
  247.     if ( tmp != 0 ) {
  248.         /* str [2] = 0; */
  249.         str = strrchr ( tmp, '#' );
  250.         str++;
  251.         str [2] = 0;
  252.         if ( (n = atoi (str)) == 0 ) {
  253.             DisplayMessage ( text -> mwin, "Abort" );
  254.             return;
  255.         }
  256.         t = TWin; 
  257.         t += (n-1);
  258.         XMapRaised ( dpy,  (*t) -> w_frame );
  259.               if ( tmp != 0 )
  260.                   (void) free ( tmp ); 
  261.               }
  262.     else
  263.         DisplayMessage ( text -> mwin, "Abort" );
  264. }
  265.  
  266.  
  267. /*
  268. **    Function name : LoadFileNames
  269. **
  270. **    Description : Construit la liste de fichiers ouverts
  271. **        en parcourant la table principale.
  272. **    Input : Un buffer pour stocker la liste.
  273. **    Ouput :
  274. */
  275. void LoadFileNames ( buf )
  276.     Buf *buf;
  277. {
  278.     register EdWin    **t;
  279.     register int i = 1;
  280.     register int j = 1;
  281.     char tmp [256];
  282.     register char *name;
  283.  
  284.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  285.         if ( *t != 0 ) {
  286.             bzero ( tmp, 256 );
  287.             if ( (name = strrchr ( (*t) -> text -> filename, '/' )) != 0 )
  288.                          if ( (*t) -> text -> modif == True ) 
  289.                     (void) sprintf ( tmp,
  290.                         " %d  : buffer #%d  **\t%s\n", i, j,(char *) (name+1) );
  291.                 else
  292.                     (void) sprintf ( tmp,
  293.                         " %d  : buffer #%d  \t%s\n", i, j,(char *) (name+1) );
  294.             else 
  295.                 (void) sprintf ( tmp,
  296.                     " %d  : buffer #%d ...\n", i, j );
  297.             InsertNchar ( buf, tmp, strlen ( tmp ));
  298.             i++;
  299.         }
  300.         j++;
  301.     }
  302. }
  303.  
  304.  
  305. /*
  306. **    Function name : IsAlreadyLoad
  307. **
  308. **    Description : Pour eviter les ouvertures multiples
  309. **        de fichiers
  310. **    Input : Le nom du fichier.
  311. **    Ouput : Le nombre de buffer ouvert sur le fichier.
  312. */
  313. int IsAlreadyLoad ( s, text )
  314.     register char *s;
  315.     Text **text;
  316. {
  317.     register EdWin    **t;
  318.        register int n = 0;
  319.  
  320.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  321.         if ( *t == 0 )
  322.              continue;
  323.         if ( strcmp ( s, (*t) -> text -> filename ) == 0 ) {
  324.             n++;
  325.                         *text = (*t) -> text;
  326.         }
  327.     }
  328.        return n;
  329. }
  330.  
  331.  
  332. /*
  333. **    Function name : NewWindow
  334. **
  335. **    Description : Construction d'une fenetre d'edition en
  336. **        tenant compte des proprietes de la fenetre parent.
  337. **    Input : Le text courant.
  338. **    Ouput :
  339. */
  340. void NewWindow ( text )
  341.     Text *text;
  342. {
  343.     EdWin     *ew;
  344.     ew = CreateWindow (); 
  345.  
  346.     if ( ew == 0 ) {
  347.         (void) fprintf ( stderr, "Too many open window\n" );
  348.         return;
  349.     }
  350.     ew -> text -> mode = text -> mode;
  351.     ew -> text -> mwin -> mode = text -> mode;
  352.     SetBrowserMode ( text -> mode );
  353.     
  354.     (void) strcpy ( ew -> text -> current_dir,
  355.             text -> current_dir );
  356. }
  357.  
  358.  
  359. /*
  360. **    Function name : DeleteWindow
  361. **
  362. **    Description : Detruit une fenetre d'edition.
  363. **    Input : Le text courant.
  364. **    Ouput : 0 si OK -1 sinon.
  365. */
  366. int DeleteWindow ( text )
  367. Text *text;
  368. {
  369.     register char *s;
  370.     char c = '\007';
  371.     register EdWin    **t, *tmp;
  372. /*   
  373.        if ( GetVisibility ( dpy, text ) == False )
  374.         return -1;
  375. */
  376.     if ( GetModif ( text ) == True ) {
  377.               if ( SaveCurrentBuffer ( text, F_MENU ) != True )
  378.                   return -1;
  379.     }
  380.     if ( IsLastWindow ( 1 ) == True ) {
  381.         s = ( char * ) GetStringFromDialogBox ( text -> window, 
  382.             "Last window. Quit [y/n] : " );
  383.         if ( (s == 0) || (strncmp(s,"y",1) == 0) ) {
  384.             DisplayMessage ( text -> mwin, "Quit" );
  385.         }
  386.         else if ( (strncmp(s,"n",1 ) == 0) || (strncmp(s,&c,1)==0) ) {
  387.             DisplayMessage ( text -> mwin, "Abort" );
  388.             return -1;
  389.         }
  390.     }
  391.  
  392.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  393.         if ( *t == 0 ) continue;
  394.         if ( text == ( *t ) -> text ) {
  395.             tmp = *t;
  396.             break;
  397.         }
  398.     }
  399.  
  400.        XUnmapWindow ( dpy, tmp -> w_frame ); 
  401.      DeleteMenu ( dpy, tmp -> menu );
  402.     DeleteBuffer ( tmp -> buf );
  403.     DeleteText ( dpy, tmp -> text );
  404.     DeleteControlPanel ( tmp -> mwin );
  405.     DeleteScroll ( dpy, tmp -> scroll );
  406.     XSync ( dpy, False );
  407.  
  408.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  409.         if ( *t == 0 ) continue;
  410.         if ( *t == tmp ) {
  411.                      if ( tmp != 0 )
  412.                 (void) free ( (char *) tmp ); 
  413.             *t = 0;
  414.             break;
  415.         }
  416.     }
  417.     return 0;
  418. }
  419.  
  420.  
  421. /*
  422. **    Function name : IsLastWindow
  423. **
  424. **    Description : Comme son l'indique.
  425. **    Input : Le nombre de fenetre.
  426. **    Ouput : Vrai ou faux.
  427. */
  428. int IsLastWindow ( nb )
  429.     register int nb;
  430. {
  431.     register EdWin    **t;
  432.     register int     n;
  433.     
  434.     n = 0;
  435.     for ( t = TWin; t < TWin + MAXWIN; t++ ) {
  436.         if ( *t != 0 )
  437.             n++;
  438.     }
  439.     if ( n != 0 ) {
  440.         if ( nb == n )
  441.             return True;
  442.         else
  443.             return False;
  444.     }
  445.     else
  446.         return True;
  447. }
  448.  
  449.  
  450. /*
  451. **    Function name : Version
  452. **
  453. **    Description : Affiche la version courante de xcoral.
  454. **    Input : Le text courant
  455. **    Ouput :
  456. */
  457. void Version ( text )
  458. Text *text;
  459. {
  460.        char tmp [64];
  461. /*   
  462.     if ( GetVisibility ( dpy, text ) != True )
  463.         return;
  464. */   
  465.        (void) sprintf ( tmp, "Message : %s", CURRENT_VERSION );
  466.     (void) GetStringFromDialogBox ( text -> window,  tmp );
  467. }
  468.  
  469.  
  470. /*
  471. **    Function name : Help
  472. **
  473. **    Description : En attendant d'avoir un help serieux.
  474. **    Input : Le text courant. 
  475. **    Ouput :
  476. */
  477. void Help ( text )
  478. Text *text;
  479. {
  480. /*
  481.     if ( GetVisibility ( dpy, text ) != True )
  482.         return;
  483. */
  484.     (void) GetStringFromDialogBox ( text -> window, 
  485.         "Message :  Help yourself" );
  486. }
  487.  
  488.  
  489.  
  490.  
  491.  
  492.